import {config} from '@/utils/config'
import store from "../store";

class Utils {
    calculateAge(birthDate) {

        /**
         * 根据生日计算年龄
         * @param {string} birthDate - 生日，格式为 'YYYY-MM-DD'
         * @returns {number} - 计算得到的年龄
         */
            // 获取当前日期
        const today = new Date();
        // 将生日字符串转换为日期对象
        const birth = new Date(birthDate);

        // 获取年份差
        let age = today.getFullYear() - birth.getFullYear();

        // 判断当前日期是否已经过了生日
        const currentMonth = today.getMonth() + 1; // 当前月份 (从 0 开始，需要加 1)
        const currentDay = today.getDate(); // 当前日期
        const birthMonth = birth.getMonth() + 1; // 生日月份
        const birthDay = birth.getDate(); // 生日日期

        // 如果当前日期还没过生日，需要减去1岁
        if (currentMonth < birthMonth || (currentMonth === birthMonth && currentDay < birthDay)) {
            age -= 1;
        }

        return age;

    }

    formatDate(inputDate, format) {
        let date = null;
        // 如果 inputDate 是时间戳，则直接创建 Date 对象
        if (inputDate) {
            if (typeof inputDate === 'string') {
                // 如果是字符串，尝试转换为日期
                date = new Date(inputDate);
            } else {
                // 如果是时间戳，直接使用
                date = new Date(inputDate * 1000);
            }
        } else {
            date = new Date()
        }

        // 提取年月日时分
        const year = date.getFullYear();
        const month = (date.getMonth() + 1).toString().padStart(2, '0'); // 获取月份（注意月份从0开始，需要加1）
        const day = date.getDate().toString().padStart(2, '0');
        const hours = date.getHours().toString().padStart(2, '0');
        const minutes = date.getMinutes().toString().padStart(2, '0');
        const seconds = date.getSeconds().toString().padStart(2, '0');

        // 格式化字符串中的占位符
        return format.replace(/yyyy/g, year)
            .replace(/MM/g, month)
            .replace(/dd/g, day)
            .replace(/hh/g, hours)
            .replace(/mm/g, minutes)
            .replace(/ss/g, seconds);
    }

    GetDateDiff(timestamp1, timestamp2, unit = 'seconds') {
        const diff = Math.abs(timestamp1 - timestamp2); // 获取时间差，单位是毫秒

        // 根据不同单位进行转换
        switch (unit) {
            case 'seconds':
                return diff / 1000; // 毫秒转秒
            case 'minutes':
                return diff / (1000 * 60); // 毫秒转分钟
            case 'hours':
                return diff / (1000 * 60 * 60); // 毫秒转小时
            case 'days':
                return diff / (1000 * 60 * 60 * 24); // 毫秒转天
            default:
                return diff / 1000; // 默认为秒
        }
    }

    formatAttachmentUrl(url) {
        if (url?.startsWith('/uploads/')||url?.startsWith('/assets/')||url?.startsWith('uploads/')) {
            return config.IMG_URL_PREFIX + url;
        }

        return url;
    }

    showImage(url) {
        uni.previewImage({
            current: '', // 当前显示图片的http链接
            urls: [url] // 需要预览的图片http链接列表
        })
    }

    showImageList(urls, index) {
        let urlList = urls.map(item => this.formatAttachmentUrl(item))
        uni.previewImage({
            urls: urlList,
            current: index
        });
    }

    upload(e, callback) {
        let headObj = {};

        // 获取token
        const token = store.state.auth.token || uni.getStorageSync('token') || '';
        if (token) headObj['token'] = token;

        const promises = e.tempFilePaths.map((item) => {
            return new Promise((resolve, reject) => {
                uni.uploadFile({
                    url: config.baseURL + 'Common/upload', //上传图片的后端接口
                    filePath: item,
                    name: 'file',
                    header: headObj,
                    success(resPath) {
                        try {
                            const response = JSON.parse(resPath.data);
                            if (response.data) {
                                resolve(response.data); // 返回上传成功的图片数据
                            } else {
                                reject('上传失败: 响应数据无效');
                            }
                        } catch (error) {
                            reject('上传失败: 响应解析错误');
                        }
                    },
                    fail(error) {
                        reject('上传失败: ' + error.errMsg);
                    }
                })
            })
        })
        Promise.all(promises).then(function (upImgList) {
            callback(upImgList)
        }).catch(function (error) {
            console.log(error)
        })

    }

    uploadImages(count = 1, callback) {
        uni.chooseImage({
            count: count, // 可以选择的图片数量（默认为1，最大为9）
            sizeType: ["original", "compressed"], // 图片的尺寸类型
            sourceType: ["album", "camera"], // 图片来源（相册或相机）
            success: (chooseImageRes) => {
                const tempFilePaths = chooseImageRes.tempFilePaths;
                if (tempFilePaths.length === 0) {
                    console.log('没有选择图片');
                    return;
                }

                this.upload({tempFilePaths}, (imgList) => {
                    // 这里可以对上传后的图片进行后续处理
                    callback(imgList); // 执行回调函数，返回上传后的图片数据
                });
            },
            fail: (error) => {
                console.log('选择图片失败: ', error);
            }
        });
    }

    back() {
        const pages = getCurrentPages();
        if (pages.length === 1) {
            // 当前是第一页，返回首页，需根据实际情况修改首页路径
            uni.reLaunch({
                url: '/pages/tabbar/index'
            });
        } else {
            // 不是第一页，正常返回上一页
            uni.navigateBack({
                delta: 1
            });
        }
    }


    jumpPage(val, mode = 'navigateTo') {
        uni[mode]({
            url: val
        })
    }

    // 封装支付请求的逻辑
    processPayment(payData, successCallback, errorCallback) {
        uni.requestPayment({
            provider: 'wxpay', // 支付服务提供商
            timeStamp: payData.timeStamp, // 时间戳
            nonceStr: payData.nonceStr, // 随机字符串
            package: payData.package,
            signType: payData.signType, // 签名算法
            paySign: payData.paySign, // 签名
            success: (res) => {
                // 在支付成功后调用传入的回调函数
                if (typeof successCallback === 'function') {
                    debugger
                    successCallback(res);
                }
            },
            fail: (err) => {
                console.log('支付失败', err);
                errorCallback(err);
            }
        });
    }


    previewFile(file) {
        uni.downloadFile({
            url: file,
            success: (res) => {
                uni.openDocument({
                    filePath: res.tempFilePath,
                    fileType: 'pdf',
                    fail: (err) => {
                        console.log(err)
                        uni.showToast({
                            title: '文件预览失败！',
                            icon: 'error',
                        })
                    },
                })
            },
            fail: (err) => {
                console.log(err)
                uni.showToast({
                    title: '文件预览失败！',
                    icon: 'error',
                })
            }
        })
    }

    // 生成时间范围的函数
    generate24HourTimeRange(start, end, interval) {
        const times = [];
        let currentTime = new Date();

        // 设置开始时间
        const [startHour, startMinute] = start.split(':').map(num => parseInt(num));
        currentTime.setHours(startHour);
        currentTime.setMinutes(startMinute);
        currentTime.setSeconds(0);
        currentTime.setMilliseconds(0);

        // 设置结束时间
        const [endHour, endMinute] = end.split(':').map(num => parseInt(num));
        const endTime = new Date();
        endTime.setHours(endHour);
        endTime.setMinutes(endMinute);
        endTime.setSeconds(0);
        endTime.setMilliseconds(0);

        // 生成时间段
        while (currentTime <= endTime) {
            const hour = currentTime.getHours().toString().padStart(2, '0');
            const minute = currentTime.getMinutes().toString().padStart(2, '0');
            times.push({name: `${hour}:${minute}`});
            currentTime.setMinutes(currentTime.getMinutes() + interval);
        }
        return times;
    }

    addMaxWidthToImages(content='') {
        return content.replace(/<img/gi, '<img style="max-width:100%;"');
    }

    getUrlParam(key,url) {
        //构造一个含有目标参数的正则表达式对象
        const reg = new RegExp("(\\?|&)" + key + "=([^&]*)(&|$)")
        var r = url.match(reg); //匹配目标参数
        if (r != null) return r[2];
        return null;
    }


}

export default new Utils();
